YES 2.257 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/empty.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ LR

mainModule Main
  ((properFraction :: Ratio Int  ->  (Int,Ratio Int)) :: Ratio Int  ->  (Int,Ratio Int))

module Main where
  import qualified Prelude



Lambda Reductions:
The following Lambda expression
\(_,r)→r

is transformed to
r0 (_,r) = r

The following Lambda expression
\(q,_)→q

is transformed to
q1 (q,_) = q



↳ HASKELL
  ↳ LR
HASKELL
      ↳ IFR

mainModule Main
  ((properFraction :: Ratio Int  ->  (Int,Ratio Int)) :: Ratio Int  ->  (Int,Ratio Int))

module Main where
  import qualified Prelude



If Reductions:
The following If expression
if primGEqNatS x y then Succ (primDivNatS (primMinusNatS x y) (Succ y)) else Zero

is transformed to
primDivNatS0 x y True = Succ (primDivNatS (primMinusNatS x y) (Succ y))
primDivNatS0 x y False = Zero

The following If expression
if primGEqNatS x y then primModNatS (primMinusNatS x y) (Succ y) else Succ x

is transformed to
primModNatS0 x y True = primModNatS (primMinusNatS x y) (Succ y)
primModNatS0 x y False = Succ x



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
HASKELL
          ↳ BR

mainModule Main
  ((properFraction :: Ratio Int  ->  (Int,Ratio Int)) :: Ratio Int  ->  (Int,Ratio Int))

module Main where
  import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
HASKELL
              ↳ COR

mainModule Main
  ((properFraction :: Ratio Int  ->  (Int,Ratio Int)) :: Ratio Int  ->  (Int,Ratio Int))

module Main where
  import qualified Prelude



Cond Reductions:
The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
HASKELL
                  ↳ LetRed

mainModule Main
  ((properFraction :: Ratio Int  ->  (Int,Ratio Int)) :: Ratio Int  ->  (Int,Ratio Int))

module Main where
  import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
(fromIntegral q,r :% y)
where 
q  = q1 vu30
q1 (q,wu) = q
r  = r0 vu30
r0 (wv,r) = r
vu30  = quotRem x y

are unpacked to the following functions on top level
properFractionVu30 wx wy = quotRem wx wy

properFractionR0 wx wy (wv,r) = r

properFractionQ wx wy = properFractionQ1 wx wy (properFractionVu30 wx wy)

properFractionQ1 wx wy (q,wu) = q

properFractionR wx wy = properFractionR0 wx wy (properFractionVu30 wx wy)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
HASKELL
                      ↳ Narrow

mainModule Main
  (properFraction :: Ratio Int  ->  (Int,Ratio Int))

module Main where
  import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
QDP
                            ↳ QDPSizeChangeProof
                          ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primMinusNatS(Succ(wz210), Succ(wz220)) → new_primMinusNatS(wz210, wz220)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
QDP
                            ↳ DependencyGraphProof
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primModNatS0(wz21, wz22, Succ(wz230), Zero) → new_primModNatS(new_primMinusNatS2(wz21, wz22), Succ(wz22))
new_primModNatS00(wz21, wz22) → new_primModNatS(new_primMinusNatS2(wz21, wz22), Succ(wz22))
new_primModNatS(Succ(Zero), Zero) → new_primModNatS(new_primMinusNatS1, Zero)
new_primModNatS(Succ(Succ(wz30000)), Succ(wz31000)) → new_primModNatS0(wz30000, wz31000, wz30000, wz31000)
new_primModNatS(Succ(Succ(wz30000)), Zero) → new_primModNatS(new_primMinusNatS0(wz30000), Zero)
new_primModNatS0(wz21, wz22, Succ(wz230), Succ(wz240)) → new_primModNatS0(wz21, wz22, wz230, wz240)
new_primModNatS0(wz21, wz22, Zero, Zero) → new_primModNatS00(wz21, wz22)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)
new_primMinusNatS1Zero
new_primMinusNatS0(wz30000) → Succ(wz30000)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS0(x0)
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 1 less node.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primModNatS(Succ(Succ(wz30000)), Zero) → new_primModNatS(new_primMinusNatS0(wz30000), Zero)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)
new_primMinusNatS1Zero
new_primMinusNatS0(wz30000) → Succ(wz30000)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS0(x0)
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primModNatS(Succ(Succ(wz30000)), Zero) → new_primModNatS(new_primMinusNatS0(wz30000), Zero)

The TRS R consists of the following rules:

new_primMinusNatS0(wz30000) → Succ(wz30000)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS0(x0)
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ RuleRemovalProof
                                ↳ QDP
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primModNatS(Succ(Succ(wz30000)), Zero) → new_primModNatS(new_primMinusNatS0(wz30000), Zero)

The TRS R consists of the following rules:

new_primMinusNatS0(wz30000) → Succ(wz30000)

The set Q consists of the following terms:

new_primMinusNatS0(x0)

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

new_primModNatS(Succ(Succ(wz30000)), Zero) → new_primModNatS(new_primMinusNatS0(wz30000), Zero)

Strictly oriented rules of the TRS R:

new_primMinusNatS0(wz30000) → Succ(wz30000)

Used ordering: POLO with Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + 2·x1   
POL(Zero) = 0   
POL(new_primMinusNatS0(x1)) = 2 + 2·x1   
POL(new_primModNatS(x1, x2)) = x1 + x2   



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ RuleRemovalProof
QDP
                                              ↳ PisEmptyProof
                                ↳ QDP
                          ↳ QDP

Q DP problem:
P is empty.
R is empty.
The set Q consists of the following terms:

new_primMinusNatS0(x0)

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primModNatS0(wz21, wz22, Succ(wz230), Zero) → new_primModNatS(new_primMinusNatS2(wz21, wz22), Succ(wz22))
new_primModNatS00(wz21, wz22) → new_primModNatS(new_primMinusNatS2(wz21, wz22), Succ(wz22))
new_primModNatS(Succ(Succ(wz30000)), Succ(wz31000)) → new_primModNatS0(wz30000, wz31000, wz30000, wz31000)
new_primModNatS0(wz21, wz22, Succ(wz230), Succ(wz240)) → new_primModNatS0(wz21, wz22, wz230, wz240)
new_primModNatS0(wz21, wz22, Zero, Zero) → new_primModNatS00(wz21, wz22)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)
new_primMinusNatS1Zero
new_primMinusNatS0(wz30000) → Succ(wz30000)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS0(x0)
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primModNatS0(wz21, wz22, Succ(wz230), Zero) → new_primModNatS(new_primMinusNatS2(wz21, wz22), Succ(wz22))
new_primModNatS00(wz21, wz22) → new_primModNatS(new_primMinusNatS2(wz21, wz22), Succ(wz22))
new_primModNatS(Succ(Succ(wz30000)), Succ(wz31000)) → new_primModNatS0(wz30000, wz31000, wz30000, wz31000)
new_primModNatS0(wz21, wz22, Succ(wz230), Succ(wz240)) → new_primModNatS0(wz21, wz22, wz230, wz240)
new_primModNatS0(wz21, wz22, Zero, Zero) → new_primModNatS00(wz21, wz22)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS0(x0)
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS0(x0)
new_primMinusNatS1



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ QDPOrderProof
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primModNatS0(wz21, wz22, Succ(wz230), Zero) → new_primModNatS(new_primMinusNatS2(wz21, wz22), Succ(wz22))
new_primModNatS00(wz21, wz22) → new_primModNatS(new_primMinusNatS2(wz21, wz22), Succ(wz22))
new_primModNatS(Succ(Succ(wz30000)), Succ(wz31000)) → new_primModNatS0(wz30000, wz31000, wz30000, wz31000)
new_primModNatS0(wz21, wz22, Zero, Zero) → new_primModNatS00(wz21, wz22)
new_primModNatS0(wz21, wz22, Succ(wz230), Succ(wz240)) → new_primModNatS0(wz21, wz22, wz230, wz240)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primModNatS0(wz21, wz22, Succ(wz230), Zero) → new_primModNatS(new_primMinusNatS2(wz21, wz22), Succ(wz22))
new_primModNatS(Succ(Succ(wz30000)), Succ(wz31000)) → new_primModNatS0(wz30000, wz31000, wz30000, wz31000)
new_primModNatS0(wz21, wz22, Zero, Zero) → new_primModNatS00(wz21, wz22)
The remaining pairs can at least be oriented weakly.

new_primModNatS00(wz21, wz22) → new_primModNatS(new_primMinusNatS2(wz21, wz22), Succ(wz22))
new_primModNatS0(wz21, wz22, Succ(wz230), Succ(wz240)) → new_primModNatS0(wz21, wz22, wz230, wz240)
Used ordering: Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + x1   
POL(Zero) = 0   
POL(new_primMinusNatS2(x1, x2)) = x1   
POL(new_primModNatS(x1, x2)) = x1   
POL(new_primModNatS0(x1, x2, x3, x4)) = 1 + x1   
POL(new_primModNatS00(x1, x2)) = x1   

The following usable rules [17] were oriented:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ QDPOrderProof
QDP
                                              ↳ DependencyGraphProof
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primModNatS00(wz21, wz22) → new_primModNatS(new_primMinusNatS2(wz21, wz22), Succ(wz22))
new_primModNatS0(wz21, wz22, Succ(wz230), Succ(wz240)) → new_primModNatS0(wz21, wz22, wz230, wz240)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ QDPOrderProof
                                            ↳ QDP
                                              ↳ DependencyGraphProof
QDP
                                                  ↳ UsableRulesProof
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primModNatS0(wz21, wz22, Succ(wz230), Succ(wz240)) → new_primModNatS0(wz21, wz22, wz230, wz240)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ QDPOrderProof
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ UsableRulesProof
QDP
                                                      ↳ QReductionProof
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primModNatS0(wz21, wz22, Succ(wz230), Succ(wz240)) → new_primModNatS0(wz21, wz22, wz230, wz240)

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ QDPOrderProof
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ UsableRulesProof
                                                    ↳ QDP
                                                      ↳ QReductionProof
QDP
                                                          ↳ QDPSizeChangeProof
                          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primModNatS0(wz21, wz22, Succ(wz230), Succ(wz240)) → new_primModNatS0(wz21, wz22, wz230, wz240)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
QDP
                            ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(wz45, wz46, Zero, Zero) → new_primDivNatS00(wz45, wz46)
new_primDivNatS0(wz45, wz46, Succ(wz470), Succ(wz480)) → new_primDivNatS0(wz45, wz46, wz470, wz480)
new_primDivNatS(Succ(Succ(wz30000)), Succ(wz31000)) → new_primDivNatS0(wz30000, wz31000, wz30000, wz31000)
new_primDivNatS00(wz45, wz46) → new_primDivNatS(new_primMinusNatS2(Succ(wz45), Succ(wz46)), Succ(wz46))
new_primDivNatS(Succ(Succ(wz30000)), Zero) → new_primDivNatS(new_primMinusNatS0(wz30000), Zero)
new_primDivNatS0(wz45, wz46, Succ(wz470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(wz45), Succ(wz46)), Succ(wz46))
new_primDivNatS(Succ(Zero), Zero) → new_primDivNatS(new_primMinusNatS1, Zero)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)
new_primMinusNatS1Zero
new_primMinusNatS0(wz30000) → Succ(wz30000)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS0(x0)
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 1 less node.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
QDP
                                  ↳ UsableRulesProof
                                ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(Succ(wz30000)), Zero) → new_primDivNatS(new_primMinusNatS0(wz30000), Zero)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)
new_primMinusNatS1Zero
new_primMinusNatS0(wz30000) → Succ(wz30000)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS0(x0)
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof
                                ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(Succ(wz30000)), Zero) → new_primDivNatS(new_primMinusNatS0(wz30000), Zero)

The TRS R consists of the following rules:

new_primMinusNatS0(wz30000) → Succ(wz30000)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS0(x0)
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ RuleRemovalProof
                                ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(Succ(wz30000)), Zero) → new_primDivNatS(new_primMinusNatS0(wz30000), Zero)

The TRS R consists of the following rules:

new_primMinusNatS0(wz30000) → Succ(wz30000)

The set Q consists of the following terms:

new_primMinusNatS0(x0)

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

new_primDivNatS(Succ(Succ(wz30000)), Zero) → new_primDivNatS(new_primMinusNatS0(wz30000), Zero)

Strictly oriented rules of the TRS R:

new_primMinusNatS0(wz30000) → Succ(wz30000)

Used ordering: POLO with Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + 2·x1   
POL(Zero) = 0   
POL(new_primDivNatS(x1, x2)) = x1 + x2   
POL(new_primMinusNatS0(x1)) = 2 + 2·x1   



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ RuleRemovalProof
QDP
                                              ↳ PisEmptyProof
                                ↳ QDP

Q DP problem:
P is empty.
R is empty.
The set Q consists of the following terms:

new_primMinusNatS0(x0)

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
QDP
                                  ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(wz45, wz46, Zero, Zero) → new_primDivNatS00(wz45, wz46)
new_primDivNatS0(wz45, wz46, Succ(wz470), Succ(wz480)) → new_primDivNatS0(wz45, wz46, wz470, wz480)
new_primDivNatS(Succ(Succ(wz30000)), Succ(wz31000)) → new_primDivNatS0(wz30000, wz31000, wz30000, wz31000)
new_primDivNatS00(wz45, wz46) → new_primDivNatS(new_primMinusNatS2(Succ(wz45), Succ(wz46)), Succ(wz46))
new_primDivNatS0(wz45, wz46, Succ(wz470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(wz45), Succ(wz46)), Succ(wz46))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)
new_primMinusNatS1Zero
new_primMinusNatS0(wz30000) → Succ(wz30000)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS0(x0)
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
QDP
                                      ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(wz45, wz46, Zero, Zero) → new_primDivNatS00(wz45, wz46)
new_primDivNatS0(wz45, wz46, Succ(wz470), Succ(wz480)) → new_primDivNatS0(wz45, wz46, wz470, wz480)
new_primDivNatS(Succ(Succ(wz30000)), Succ(wz31000)) → new_primDivNatS0(wz30000, wz31000, wz30000, wz31000)
new_primDivNatS00(wz45, wz46) → new_primDivNatS(new_primMinusNatS2(Succ(wz45), Succ(wz46)), Succ(wz46))
new_primDivNatS0(wz45, wz46, Succ(wz470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(wz45), Succ(wz46)), Succ(wz46))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS0(x0)
new_primMinusNatS1
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS0(x0)
new_primMinusNatS1



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
QDP
                                          ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(wz45, wz46, Zero, Zero) → new_primDivNatS00(wz45, wz46)
new_primDivNatS(Succ(Succ(wz30000)), Succ(wz31000)) → new_primDivNatS0(wz30000, wz31000, wz30000, wz31000)
new_primDivNatS0(wz45, wz46, Succ(wz470), Succ(wz480)) → new_primDivNatS0(wz45, wz46, wz470, wz480)
new_primDivNatS00(wz45, wz46) → new_primDivNatS(new_primMinusNatS2(Succ(wz45), Succ(wz46)), Succ(wz46))
new_primDivNatS0(wz45, wz46, Succ(wz470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(wz45), Succ(wz46)), Succ(wz46))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primDivNatS00(wz45, wz46) → new_primDivNatS(new_primMinusNatS2(Succ(wz45), Succ(wz46)), Succ(wz46)) at position [0] we obtained the following new rules:

new_primDivNatS00(wz45, wz46) → new_primDivNatS(new_primMinusNatS2(wz45, wz46), Succ(wz46))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
QDP
                                              ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(wz45, wz46, Zero, Zero) → new_primDivNatS00(wz45, wz46)
new_primDivNatS0(wz45, wz46, Succ(wz470), Succ(wz480)) → new_primDivNatS0(wz45, wz46, wz470, wz480)
new_primDivNatS(Succ(Succ(wz30000)), Succ(wz31000)) → new_primDivNatS0(wz30000, wz31000, wz30000, wz31000)
new_primDivNatS00(wz45, wz46) → new_primDivNatS(new_primMinusNatS2(wz45, wz46), Succ(wz46))
new_primDivNatS0(wz45, wz46, Succ(wz470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(wz45), Succ(wz46)), Succ(wz46))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primDivNatS0(wz45, wz46, Succ(wz470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(wz45), Succ(wz46)), Succ(wz46)) at position [0] we obtained the following new rules:

new_primDivNatS0(wz45, wz46, Succ(wz470), Zero) → new_primDivNatS(new_primMinusNatS2(wz45, wz46), Succ(wz46))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
QDP
                                                  ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS0(wz45, wz46, Zero, Zero) → new_primDivNatS00(wz45, wz46)
new_primDivNatS0(wz45, wz46, Succ(wz470), Zero) → new_primDivNatS(new_primMinusNatS2(wz45, wz46), Succ(wz46))
new_primDivNatS(Succ(Succ(wz30000)), Succ(wz31000)) → new_primDivNatS0(wz30000, wz31000, wz30000, wz31000)
new_primDivNatS0(wz45, wz46, Succ(wz470), Succ(wz480)) → new_primDivNatS0(wz45, wz46, wz470, wz480)
new_primDivNatS00(wz45, wz46) → new_primDivNatS(new_primMinusNatS2(wz45, wz46), Succ(wz46))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primDivNatS0(wz45, wz46, Zero, Zero) → new_primDivNatS00(wz45, wz46)
new_primDivNatS0(wz45, wz46, Succ(wz470), Zero) → new_primDivNatS(new_primMinusNatS2(wz45, wz46), Succ(wz46))
new_primDivNatS(Succ(Succ(wz30000)), Succ(wz31000)) → new_primDivNatS0(wz30000, wz31000, wz30000, wz31000)
new_primDivNatS0(wz45, wz46, Succ(wz470), Succ(wz480)) → new_primDivNatS0(wz45, wz46, wz470, wz480)
The remaining pairs can at least be oriented weakly.

new_primDivNatS00(wz45, wz46) → new_primDivNatS(new_primMinusNatS2(wz45, wz46), Succ(wz46))
Used ordering: Matrix interpretation [3]:
Non-tuple symbols:
M( Succ(x1) ) =
/1\
\1/
+
/11\
\10/
·x1

M( new_primMinusNatS2(x1, x2) ) =
/0\
\0/
+
/10\
\11/
·x1+
/00\
\11/
·x2

M( Zero ) =
/0\
\0/

Tuple symbols:
M( new_primDivNatS00(x1, x2) ) = 0+
[1,0]
·x1+
[0,0]
·x2

M( new_primDivNatS(x1, x2) ) = 0+
[1,0]
·x1+
[0,0]
·x2

M( new_primDivNatS0(x1, ..., x4) ) = 1+
[1,0]
·x1+
[0,0]
·x2+
[1,1]
·x3+
[0,0]
·x4


Matrix type:
We used a basic matrix type which is not further parametrizeable.


As matrix orders are CE-compatible, we used usable rules w.r.t. argument filtering in the order.
The following usable rules [17] were oriented:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ Narrow
                        ↳ AND
                          ↳ QDP
                          ↳ QDP
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ AND
                                ↳ QDP
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ QReductionProof
                                        ↳ QDP
                                          ↳ Rewriting
                                            ↳ QDP
                                              ↳ Rewriting
                                                ↳ QDP
                                                  ↳ QDPOrderProof
QDP
                                                      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS00(wz45, wz46) → new_primDivNatS(new_primMinusNatS2(wz45, wz46), Succ(wz46))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(wz210), Succ(wz220)) → new_primMinusNatS2(wz210, wz220)
new_primMinusNatS2(Zero, Succ(wz220)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(wz210), Zero) → Succ(wz210)

The set Q consists of the following terms:

new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))
new_primMinusNatS2(Zero, Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 1 less node.